{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bb375284",
   "metadata": {},
   "source": [
    "# Creating Knowledge graphs from Pdf files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "3e44b03b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.graphs import Neo4jGraph\n",
    "\n",
    "url = \"\"\n",
    "username =\"\"\n",
    "password = \"\"\n",
    "graph = Neo4jGraph(\n",
    "    url=url,\n",
    "    username=username,\n",
    "    password=password\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "98e7e6c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from dotenv import load_dotenv \n",
    "from langchain_community.graphs.graph_document import (\n",
    "    Node as BaseNode,\n",
    "    Relationship as BaseRelationship,\n",
    "    GraphDocument,\n",
    ")\n",
    "from langchain.schema import Document\n",
    "from typing import List, Dict, Any, Optional\n",
    "from langchain.pydantic_v1 import Field, BaseModel\n",
    "\n",
    "load_dotenv()\n",
    "\n",
    "# Add OpenAI key\n",
    "#os.environ['OPENAI_API_KEY']=''\n",
    "api_key = os.environ['OPENAI_API_KEY']\n",
    "\n",
    "class Property(BaseModel):\n",
    "  \"\"\"A single property consisting of key and value\"\"\"\n",
    "  key: str = Field(..., description=\"key\")\n",
    "  value: str = Field(..., description=\"value\")\n",
    "\n",
    "class Node(BaseNode):\n",
    "    properties: Optional[List[Property]] = Field(\n",
    "        None, description=\"List of node properties\")\n",
    "\n",
    "class Relationship(BaseRelationship):\n",
    "    properties: Optional[List[Property]] = Field(\n",
    "        None, description=\"List of relationship properties\"\n",
    "    )\n",
    "\n",
    "# class Source(BaseSource):\n",
    "#     properties: Optional[List[Property]] = Field(\n",
    "#         None, description=\"List of sources\"\n",
    "#     )        \n",
    "        \n",
    "class KnowledgeGraph(BaseModel):\n",
    "    \"\"\"Generate a knowledge graph with entities and relationships.\"\"\"\n",
    "    nodes: List[Node] = Field(\n",
    "        ..., description=\"List of nodes in the knowledge graph\")\n",
    "    rels: List[Relationship] = Field(\n",
    "        ..., description=\"List of relationships in the knowledge graph\"\n",
    "    )\n",
    "    \n",
    "def format_property_key(s: str) -> str:\n",
    "    words = s.split()\n",
    "    if not words:\n",
    "        return s\n",
    "    first_word = words[0].lower()\n",
    "    capitalized_words = [word.capitalize() for word in words[1:]]\n",
    "    return \"\".join([first_word] + capitalized_words)\n",
    "\n",
    "def props_to_dict(props) -> dict:\n",
    "    \"\"\"Convert properties to a dictionary.\"\"\"\n",
    "    properties = {}\n",
    "    if not props:\n",
    "      return properties\n",
    "    for p in props:\n",
    "        properties[format_property_key(p.key)] = p.value\n",
    "    return properties\n",
    "\n",
    "def map_to_base_node(node: Node) -> BaseNode:\n",
    "    \"\"\"Map the KnowledgeGraph Node to the base Node.\"\"\"\n",
    "    properties = props_to_dict(node.properties) if node.properties else {}\n",
    "    # Add name property for better Cypher statement generation\n",
    "    properties[\"name\"] = node.id.title()\n",
    "    return BaseNode(\n",
    "        id=node.id.title(), type=node.type.capitalize(), properties=properties\n",
    "    )\n",
    "\n",
    "\n",
    "def map_to_base_relationship(rel: Relationship) -> BaseRelationship:\n",
    "    \"\"\"Map the KnowledgeGraph Relationship to the base Relationship.\"\"\"\n",
    "    source = map_to_base_node(rel.source)\n",
    "    target = map_to_base_node(rel.target)\n",
    "    properties = props_to_dict(rel.properties) if rel.properties else {}\n",
    "    return BaseRelationship(\n",
    "        source=source, target=target, type=rel.type, properties=properties\n",
    "    )    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eaf6d19f",
   "metadata": {},
   "source": [
    "# Using GPT-3.5-turbo-16k model to create the knowledge graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "505a5db2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from langchain.chains.openai_functions import (\n",
    "    create_openai_fn_chain,\n",
    "    create_structured_output_chain,\n",
    ")\n",
    "from langchain_openai import ChatOpenAI\n",
    "from langchain.prompts import ChatPromptTemplate\n",
    "\n",
    "# os.environ[\"OPENAI_API_KEY\"] = \"sk-\"\n",
    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-16k\", temperature=0)\n",
    "\n",
    "def get_extraction_chain(\n",
    "    input,\n",
    "    allowed_nodes: Optional[List[str]] = None,\n",
    "    allowed_rels: Optional[List[str]] = None\n",
    "    ):\n",
    "    prompt = ChatPromptTemplate.from_messages(\n",
    "        [(\n",
    "          \"system\",\n",
    "          f\"\"\"# Knowledge Graph Instructions for GPT-3.5\n",
    "## 1. Overview\n",
    "You are a top-tier algorithm designed for extracting information in structured formats to build a knowledge graph.\n",
    "- **Nodes** represent entities and concepts. They're akin to Wikipedia nodes.\n",
    "- The aim is to achieve simplicity and clarity in the knowledge graph, making it accessible for a vast audience.\n",
    "## 2. Labeling Nodes\n",
    "- **Consistency**: Ensure you use basic or elementary types for node labels.\n",
    "  - For example, when you identify an entity representing a person, always label it as **\"person\"**. Avoid using more specific terms like \"mathematician\" or \"scientist\".\n",
    "- **Node IDs**: Never utilize integers as node IDs. Node IDs should be names or human-readable identifiers found in the text.\n",
    "{'- **Allowed Node Labels:**' + \", \".join(allowed_nodes) if allowed_nodes else \"\"}\n",
    "{'- **Allowed Relationship Types**:' + \", \".join(allowed_rels) if allowed_rels else \"\"}\n",
    "## 3. Handling Numerical Data and Dates\n",
    "- Numerical data, like age or other related information, should be incorporated as attributes or properties of the respective nodes.\n",
    "- **No Separate Nodes for Dates/Numbers**: Do not create separate nodes for dates or numerical values. Always attach them as attributes or properties of nodes.\n",
    "- **Property Format**: Properties must be in a key-value format.\n",
    "- **Quotation Marks**: Never use escaped single or double quotes within property values.\n",
    "- **Naming Convention**: Use camelCase for property keys, e.g., `birthDate`.\n",
    "## 4. Coreference Resolution\n",
    "- **Maintain Entity Consistency**: When extracting entities, it's vital to ensure consistency.\n",
    "If an entity, such as \"John Doe\", is mentioned multiple times in the text but is referred to by different names or pronouns (e.g., \"Joe\", \"he\"),\n",
    "always use the most complete identifier for that entity throughout the knowledge graph. In this example, use \"John Doe\" as the entity ID.\n",
    "Remember, the knowledge graph should be coherent and easily understandable, so maintaining consistency in entity references is crucial.\n",
    "## 5. Strict Compliance\n",
    "Adhere to the rules strictly. Non-compliance will result in termination.\n",
    "          \"\"\"),\n",
    "            (\"human\", \"Use the given format to extract information from the following input: {input}\"),\n",
    "            (\"human\", \"Tip: Make sure to answer in the correct format\"),\n",
    "        ])\n",
    "    return create_structured_output_chain(KnowledgeGraph, llm, prompt, verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "cf8b15fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import threading\n",
    "import time\n",
    "\n",
    "def extract_and_store_graph(\n",
    "    document: Document,\n",
    "    nodes:Optional[List[str]] = None,\n",
    "    rels:Optional[List[str]]=None) -> None:\n",
    "    # Extract graph data using OpenAI functions\n",
    "    extract_chain = get_extraction_chain(document.page_content,nodes, rels)\n",
    "    data = extract_chain.invoke(document.page_content)['function']\n",
    "    # Construct a graph document\n",
    "    graph_document = GraphDocument(\n",
    "      nodes = [map_to_base_node(node) for node in data.nodes],\n",
    "      relationships = [map_to_base_relationship(rel) for rel in data.rels],\n",
    "      source = document\n",
    "    )\n",
    "    # Store information into a graph\n",
    "    graph.add_graph_documents([graph_document])\n",
    "    return graph_document"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "4b68b8c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import unicodedata \n",
    "\n",
    "def filter_text(text):\n",
    "    # regex pattern to match ascii characters and currency symbols\n",
    "    pattern = re.compile(r'[^\\x20-\\x7E\\u20A0-\\u20CF\\u20E0-\\u20FF]')\n",
    "    # Use the pattern to filter out non-English characters\n",
    "    filtered_text = re.sub(pattern, '', text)\n",
    "    \n",
    "    return filtered_text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "b7552cce",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from langchain.text_splitter import TokenTextSplitter\n",
    "\n",
    "from langchain_community.document_loaders import PyPDFLoader\n",
    "\n",
    "from datetime import datetime\n",
    "\n",
    "\n",
    "loader = PyPDFLoader(\"../data/new_york_city_example_itinerary.pdf\")\n",
    "\n",
    "pages = loader.load()\n",
    "\n",
    "for page in pages:\n",
    "    page.page_content = filter_text(page.page_content)\n",
    "# Define chunking strategy\n",
    "text_splitter = TokenTextSplitter(chunk_size=200, chunk_overlap=20)\n",
    "\n",
    "# Only take the first 4 pages of the document\n",
    "documents = text_splitter.split_documents(pages)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "6e98946e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(documents)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8c0e0d1",
   "metadata": {},
   "source": [
    "Replacing currency symbols with respective unicode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50c12101",
   "metadata": {},
   "outputs": [],
   "source": [
    "for doc in documents:\n",
    "        currency_symbol = None  \n",
    "        for char in doc.page_content:  \n",
    "                if unicodedata.category(char) == \"Sc\":  \n",
    "                        currency_symbol = char  \n",
    "                        break  \n",
    "        # Convert the currency symbol to a Unicode escape sequence  \n",
    "        if currency_symbol is not None:  \n",
    "                encoded_symbol = \"\\\\u\" + hex(ord(currency_symbol))[2:].zfill(4)  \n",
    "                doc.page_content = doc.page_content.replace(currency_symbol, encoded_symbol)  \n",
    "                print(doc.page_content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "40640370",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_nodes_and_relations_count(graph_document_list: List[GraphDocument]):\n",
    "    distinct_nodes = set()\n",
    "    relations = []\n",
    "\n",
    "    for graph_document in graph_document_list:\n",
    "        #get distinct nodes\n",
    "        for node in graph_document.nodes:\n",
    "                node_id = node.id\n",
    "                node_type= node.type\n",
    "                if (node_id, node_type) not in distinct_nodes:\n",
    "                    distinct_nodes.add((node_id, node_type))\n",
    "        #get all relations\n",
    "        for relation in graph_document.relationships:\n",
    "                relations.append(relation.type)\n",
    "            \n",
    "    print(\"nodes = \",len(distinct_nodes))   \n",
    "    print(\"relations = \",len(relations)) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "415e8f2c",
   "metadata": {},
   "source": [
    "Sequencial Processing of chunks (chunk size 200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "14a6fb0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 15/15 [03:20<00:00, 13.33s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing_time =  0:03:20.005178\n",
      "nodes =  108\n",
      "relations =  107\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "distinct_nodes = set()\n",
    "relations = []\n",
    "graph_document_list=[]\n",
    "start_time = datetime.now()\n",
    "\n",
    "for i, d in tqdm(enumerate(documents), total=len(documents)):\n",
    "    graph_document=extract_and_store_graph(d)\n",
    "\n",
    "    graph_document_list.append(graph_document)\n",
    "\n",
    "end_time = datetime.now()  \n",
    "print(\"Processing_time = \", end_time-start_time) \n",
    "get_nodes_and_relations_count(graph_document_list) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43d9bd6c",
   "metadata": {},
   "source": [
    "Parallel Processing chunk with ThreadPool size 8 (chunk size 200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "3bd6ed8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 15/15 [00:00<00:00, 168.07it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing_time =  0:00:28.000194\n",
      "nodes =  108\n",
      "relations =  101\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "import concurrent.futures\n",
    "from concurrent.futures import ThreadPoolExecutor\n",
    "\n",
    "graph_document_list=[]\n",
    "futures=[]\n",
    "start_time = datetime.now()\n",
    "with ThreadPoolExecutor(max_workers=8) as executor:\n",
    "    \n",
    "    for i,chunk in tqdm(enumerate(documents), total=len(documents)):\n",
    "        futures.append(executor.submit(extract_and_store_graph,chunk))\n",
    "    \n",
    "    for future in concurrent.futures.as_completed(futures):\n",
    "        graph_document_list.append(future.result())\n",
    "    \n",
    "end_time = datetime.now()  \n",
    "print(\"Processing_time = \", end_time-start_time) \n",
    "get_nodes_and_relations_count(graph_document_list) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc4adf01",
   "metadata": {},
   "source": [
    "Combined 2 chunks and sequential processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "a3494bab",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 8/8 [01:41<00:00, 12.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing_time =  0:01:41.191927\n",
      "nodes =  76\n",
      "relations =  52\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "graph_document_list=[]\n",
    "futures=[]\n",
    "combined_chunk=''\n",
    "combined_chunk_document_list=[]\n",
    "   \n",
    "combined_chunks = [\"\".join(document.page_content for document in documents[i:i+2]) for i in range(0, len(documents),2)]\n",
    "\n",
    "for i in range(len(combined_chunks)):\n",
    "        combined_chunk_document_list.append(Document(page_content=combined_chunks[i]))       \n",
    "        \n",
    "start_time = datetime.now()\n",
    "     \n",
    "for i, d in tqdm(enumerate(combined_chunk_document_list), total=len(combined_chunk_document_list)):\n",
    "    graph_document=extract_and_store_graph(d)\n",
    "    graph_document_list.append(graph_document)\n",
    "        \n",
    "end_time = datetime.now()  \n",
    "print(\"Processing_time = \", end_time-start_time) \n",
    "get_nodes_and_relations_count(graph_document_list)         "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e457aef",
   "metadata": {},
   "source": [
    "Combined 2 chunks and Parallel processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "f14f9b60",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 8/8 [00:00<00:00, 72.09it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing_time =  0:00:41.756752\n",
      "nodes =  77\n",
      "relations =  54\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "import concurrent.futures\n",
    "from concurrent.futures import ThreadPoolExecutor\n",
    "\n",
    "graph_document_list=[]\n",
    "futures=[]\n",
    "combined_chunk=''\n",
    "combined_chunk_document_list=[]\n",
    "   \n",
    "combined_chunks = [\"\".join(document.page_content for document in documents[i:i+2]) for i in range(0, len(documents),2)]\n",
    "\n",
    "start_time = datetime.now()\n",
    "     \n",
    "with ThreadPoolExecutor(max_workers=10) as executor:\n",
    "    for i in range(len(combined_chunks)):\n",
    "        combined_chunk_document_list.append(Document(page_content=combined_chunks[i]))\n",
    " \n",
    "    for i,chunk in tqdm(enumerate(combined_chunk_document_list), total=len(combined_chunk_document_list)):\n",
    "        futures.append(executor.submit(extract_and_store_graph,chunk))\n",
    "    \n",
    "    for future in concurrent.futures.as_completed(futures):\n",
    "        graph_document_list.append(future.result())\n",
    "        \n",
    "end_time = datetime.now()  \n",
    "print(\"Processing_time = \", end_time-start_time) \n",
    "get_nodes_and_relations_count(graph_document_list)         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "97fe1799",
   "metadata": {},
   "outputs": [],
   "source": [
    "loader = PyPDFLoader(\"../data/new_york_city_example_itinerary.pdf\")\n",
    "pages = loader.load()\n",
    "for page in pages:\n",
    "    page.page_content = filter_text(page.page_content)\n",
    "# Define chunking strategy\n",
    "text_splitter = TokenTextSplitter(chunk_size=500, chunk_overlap=20)\n",
    "\n",
    "documents = text_splitter.split_documents(pages)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "aa1f5b83",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(documents)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d711bf8",
   "metadata": {},
   "source": [
    "Sequential processing of chunk (Chunk size 500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "89901d6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 7/7 [01:53<00:00, 16.18s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing_time =  0:01:53.235920\n",
      "nodes =  71\n",
      "relations =  69\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "distinct_nodes = set()\n",
    "relations = []\n",
    "graph_document_list=[]\n",
    "start_time = datetime.now()\n",
    "\n",
    "for i, d in tqdm(enumerate(documents), total=len(documents)):\n",
    "    graph_document=extract_and_store_graph(d)\n",
    "\n",
    "    graph_document_list.append(graph_document)\n",
    "\n",
    "end_time = datetime.now()  \n",
    "print(\"Processing_time = \", end_time-start_time) \n",
    "get_nodes_and_relations_count(graph_document_list) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9378cbb",
   "metadata": {},
   "source": [
    "Parallel Processing chunk with ThreadPool size 8 (chunk size 500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "3f8614e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 7/7 [00:00<00:00, 132.89it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing_time =  0:00:25.987004\n",
      "nodes =  70\n",
      "relations =  59\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "import concurrent.futures\n",
    "from concurrent.futures import ThreadPoolExecutor\n",
    "\n",
    "graph_document_list=[]\n",
    "futures=[]\n",
    "start_time = datetime.now()\n",
    "with ThreadPoolExecutor(max_workers=8) as executor:\n",
    "    \n",
    "    for i,chunk in tqdm(enumerate(documents), total=len(documents)):\n",
    "        futures.append(executor.submit(extract_and_store_graph,chunk))\n",
    "    \n",
    "    for future in concurrent.futures.as_completed(futures):\n",
    "        graph_document_list.append(future.result())\n",
    "    \n",
    "end_time = datetime.now()  \n",
    "print(\"Processing_time = \", end_time-start_time) \n",
    "get_nodes_and_relations_count(graph_document_list) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25c89eec",
   "metadata": {},
   "source": [
    "Combined 2 chunks and sequential processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "44f25a40",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4/4 [01:46<00:00, 26.71s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing_time =  0:01:46.847089\n",
      "nodes =  53\n",
      "relations =  5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "graph_document_list=[]\n",
    "futures=[]\n",
    "combined_chunk=''\n",
    "combined_chunk_document_list=[]\n",
    "   \n",
    "combined_chunks = [\"\".join(document.page_content for document in documents[i:i+2]) for i in range(0, len(documents),2)]\n",
    "\n",
    "for i in range(len(combined_chunks)):\n",
    "        combined_chunk_document_list.append(Document(page_content=combined_chunks[i]))       \n",
    "        \n",
    "start_time = datetime.now()\n",
    "     \n",
    "for i, d in tqdm(enumerate(combined_chunk_document_list), total=len(combined_chunk_document_list)):\n",
    "    graph_document=extract_and_store_graph(d)\n",
    "    graph_document_list.append(graph_document)\n",
    "        \n",
    "end_time = datetime.now()  \n",
    "print(\"Processing_time = \", end_time-start_time) \n",
    "get_nodes_and_relations_count(graph_document_list)         "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f22c323e",
   "metadata": {},
   "source": [
    "Combined 2 chunks and Parallel processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "ce092689",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4/4 [00:00<00:00, 135.80it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing_time =  0:00:22.058208\n",
      "nodes =  53\n",
      "relations =  18\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "import concurrent.futures\n",
    "from concurrent.futures import ThreadPoolExecutor\n",
    "\n",
    "graph_document_list=[]\n",
    "futures=[]\n",
    "combined_chunk=''\n",
    "combined_chunk_document_list=[]\n",
    "   \n",
    "combined_chunks = [\"\".join(document.page_content for document in documents[i:i+2]) for i in range(0, len(documents),2)]\n",
    "\n",
    "start_time = datetime.now()\n",
    "     \n",
    "with ThreadPoolExecutor(max_workers=10) as executor:\n",
    "    for i in range(len(combined_chunks)):\n",
    "        combined_chunk_document_list.append(Document(page_content=combined_chunks[i]))\n",
    " \n",
    "    for i,chunk in tqdm(enumerate(combined_chunk_document_list), total=len(combined_chunk_document_list)):\n",
    "        futures.append(executor.submit(extract_and_store_graph,chunk))\n",
    "    \n",
    "    for future in concurrent.futures.as_completed(futures):\n",
    "        graph_document_list.append(future.result())\n",
    "        \n",
    "end_time = datetime.now()  \n",
    "print(\"Processing_time = \", end_time-start_time) \n",
    "get_nodes_and_relations_count(graph_document_list)         "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "256aeb9a",
   "metadata": {},
   "source": [
    "Observation - \n",
    "When combining chunks/increasing size :\n",
    "1. Some of the irrelevant nodes/relations are not getting created\n",
    "\n",
    "2. more properties are getting added to nodes\n",
    "\n",
    "3. But some information is missed as well in nodes (Example : For chunk of 200 we got relations - Relationship(source=Node(id='Ms. Amanda', type='Person', properties={'name': 'Ms. Amanda'}), target=Node(id='Ice Skating', type='Activity', properties={'name': 'Ice Skating'}), type='receives payment'), Relationship(source=Node(id='Mr. Greg', type='Person', properties={'name': 'Mr. Greg'}), target=Node(id='Ice Skating', type='Activity', properties={'name': 'Ice Skating'}), type='receives payment')) but after combining no nodes are created with name Ms. Amanda and Mr. Greg"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "6da53dd4",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
